package com.tiny.tinyweb.core.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.time.FastDateFormat;


/**
 * 类型和格式转换的工具类。
 *
 * @author wxiaobin
 */
public class ConversionUtils {
    /**
     * 将驼峰式命名的字符串转换为下划线大写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。</br>
     * 例如：HelloWorld->HELLO_WORLD
     *
     * @param name 转换前的驼峰式命名的字符串
     * @return 转换后下划线大写方式命名的字符串
     */
    public static String underscoreName(String name) {
        StringBuilder result = new StringBuilder();
        if (name != null && name.length() > 0) {
            // 将第一个字符处理成大写
            result.append(name.substring(0, 1).toUpperCase());
            // 循环处理其余字符
            for (int i = 1; i < name.length(); i++) {
                String s = name.substring(i, i + 1);
                // 在大写字母前添加下划线
                if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
                    result.append("_");
                }
                // 其他字符直接转成大写
                result.append(s.toUpperCase());
            }
        }
        return result.toString();
    }

    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
     * 例如：HELLO_WORLD->HelloWorld
     *
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String camelName(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，如果全部为大写字母，则全部转换为小写，否则仅将首字母小写
            if (Pattern.compile("^([A-Z0-9]+)$").matcher(name).matches()) {
                return name.toLowerCase();
            } else {
                return name.substring(0, 1).toLowerCase() + name.substring(1);
            }
        }
        // 用下划线将原始字符串分割
        String camels[] = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 处理真正的驼峰片段
            if (result.length() == 0) {
                // 第一个驼峰片段，全部字母都小写
                result.append(camel.toLowerCase());
            } else {
                // 其他的驼峰片段，首字母大写
                result.append(camel.substring(0, 1).toUpperCase());
                result.append(camel.substring(1).toLowerCase());
            }
        }
        return result.toString();
    }

    /**
     * 将指定的字符替换成指定的字符串，可消除重复字符。</br> 例如：调用
     * multiToSingle(" Hello   java world.  ", ' ', " ")，会返回"Hello java world."。
     *
     * @param original 替换前字符串
     * @param oldChar 要替换掉的字符
     * @param replacement 要替换的字符串
     * @return 替换后字符串
     */
    public static String multiToSingle(String original, char oldChar, String replacement) {
        if (original == null || original.isEmpty()) {
            return "";
        }
        String regEx = "['" + oldChar + "']+";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(original);
        return m.replaceAll(replacement).trim();
    }

    /**
     * 将日期字符串转换为日期格式。
     * @param source 日期字符串
     * @param format 转换格式（如yyyy-MM-dd HH:mm:ss），可以不指定
     * @return 转换后的日期
     * @throws Exception
     * @see {@link org.apache.commons.lang3.time.FastDateFormat#parse(String)}
     */
    public static Date parseDate(String source, String...format) {
        try {
            if (Pattern.compile("^\\d{4}[^0-9]{1}\\d{1,2}[^0-9]{1}\\d{1,2}$").matcher(source).find()) {
                source = source + " 00:00:00";
                source = source.replaceAll("-", "/");
            } else if (Pattern.compile("^\\d{8}$").matcher(source).find()) {
                source = String.format("%s/%s/%s%s",
                        source.substring(0, 4), source.substring(4, 6), source.substring(6, 8), " 00:00:00");
            }
            if (format.length > 0) {
                return FastDateFormat.getInstance(format[0]).parse(source);
            } else {
                return FastDateFormat.getInstance("yyyy/MM/dd HH:mm:ss").parse(source);
            }
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将日期格式转换为日期字符串。
     * @param source 日期
     * @param format 转换格式（如yyyy-MM-dd HH:mm:ss），可以不指定
     * @return 转换后的日期字符串
     * @throws Exception
     * @see {@link org.apache.commons.lang3.time.FastDateFormat#parse(String)}
     */
    public static String formatDate(Date source, String...format) {
        try {
            if (format.length > 0) {
                return new SimpleDateFormat(format[0]).format(source);
            } else {
                return new SimpleDateFormat().format(source);
            }
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 使用参数Format将字符串转为Date
     */
    public static Date StringToDate(String strDate, String pattern)
    {
        try {
			return new SimpleDateFormat(
			        pattern).parse(strDate);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
    }

    public static void main(String[] args) {
		String str = "2015-07-18 20:00:00";
		System.out.println(parseDate(str,"yyyy-MM-dd HH:mm:ss"));
		System.out.println(StringToDate(str,"yyyy-mm-dd HH:mm:ss"));
	}

}
